package com.liuyjy.redis.util;

import org.springframework.data.redis.core.*;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @author: liuyjy
 * @Description: redis封装方法
 * @date: 2022/2/10 16:34
 */
public interface RedisCache {

/**
 * ------------------------------------------通用----------------------------------------------
 */
    /**
     * 获取RedisTemplate对象
     *
     * @return RedisTemplate<String, Object>
     */
    RedisTemplate<String, Object> getRedisTemplate();

    /**
     * 获取ListOperations对象
     *
     * @return ListOperations
     */
    ListOperations<String, Object> getListOperations();

    /**
     * 获取ValueOperations对象
     *
     * @return ValueOperations
     */
    ValueOperations<String, Object> getValueOperations();

    /**
     * 获取SetOperations对象
     *
     * @return SetOperations
     */
    SetOperations<String, Object> getSetOperations();

    /**
     * 获取HashOperations对象
     *
     * @return HashOperations
     */
    <T> HashOperations<String, String, T> getHashOperations();

    /**
     * 获取ZSetOperations对象
     * 用于执行与有序集合相关的操作
     *
     * @return ZSetOperations
     */
    ZSetOperations<String, Object> getZSetOperations();

    /**
     * 获取StreamOperations对象
     * 该方法用于获取RedisTemplate中的Stream操作对象，以便进行流数据的处理和操作
     *
     * @return StreamOperations<String, Object, Object> 返回一个StreamOperations对象，用于操作Redis中的流数据
     */
    StreamOperations<String, String, Object> getStreamOperations();

    /**
     * 获取ClusterOperations对象
     *
     * @return ClusterOperations
     */
    ClusterOperations<String, Object> getClusterOperations();

    /**
     * 获取GeoOperations对象
     *
     * @return GeoOperations
     */
    GeoOperations<String, Object> getGeoOperations();

    /**
     * 获取HyperLogLogOperations对象
     * 该方法用于从RedisTemplate中获取HyperLogLog操作的实例
     * 主要用于执行HyperLogLog相关的操作，如添加元素、计算近似集合大小等
     *
     * @return HyperLogLogOperations<String, Object> 返回一个HyperLogLog操作的实例
     */
    HyperLogLogOperations<String, Object> getHyperLogLogOperations();

    /**
     * 设置有效时间
     *
     * @param k       主键，用于标识数据的主键
     * @param subK    子键，用于标识数据的子键
     * @param seconds 数据的生命时长 （秒）
     * @return boolean
     */
    boolean expire(String k, String subK, final long seconds);

    /**
     * 设置有效时间
     *
     * @param k       储存的数据的键
     * @param seconds 数据的生命时长 （秒）
     * @return boolean
     */
    boolean expire(String k, final long seconds);

    /**
     * 设置有效时间
     * <p>
     * 该方法用于检查给定的键和子键组合是否存在于数据结构中
     * 它通过将键和子键连接起来形成一个复合键，然后检查这个复合键是否存在
     *
     * @param k       主键，用于标识数据的主键
     * @param subK    子键，用于标识数据的子键
     * @param timeout 数据的生命时长
     * @param unit    时长类型
     * @return boolean
     */
    boolean expire(String k, String subK, final long timeout, final TimeUnit unit);

    /**
     * 设置有效时间
     *
     * @param k       储存的数据的键
     * @param timeout 数据的生命时长
     * @param unit    时长类型
     * @return boolean
     */
    boolean expire(String k, final long timeout, final TimeUnit unit);

    /**
     * 设置有效时间
     * 将给定键的过期时间设置为日期时间戳。
     *
     * @param k             主键，用于标识数据的主键
     * @param subK          子键，用于标识数据的子键
     * @param localDateTime 数据的生命时长 （秒）
     * @return boolean
     */
    boolean expireAt(String k, String subK, LocalDateTime localDateTime);

    /**
     * 设置有效时间
     * 将给定键的过期时间设置为日期时间戳。
     *
     * @param k         储存的数据的键
     * @param localDate 数据的生命时长 （秒）
     * @return boolean
     */
    boolean expireAt(String k, LocalDate localDate);

    /**
     * 设置有效时间
     * 将给定键的过期时间设置为日期时间戳。
     *
     * @param k         主键，用于标识数据的主键
     * @param subK      子键，用于标识数据的子键
     * @param localDate 数据的生命时长 （秒）
     * @return boolean
     */
    boolean expireAt(String k, String subK, LocalDate localDate);

    /**
     * 设置有效时间
     * 将给定键的过期时间设置为日期时间戳。
     *
     * @param k             储存的数据的键
     * @param localDateTime 数据的生命时长 （秒）
     * @return boolean
     */
    boolean expireAt(String k, LocalDateTime localDateTime);

    /**
     * 获取剩余时间
     *
     * @param key 储存的数据的键
     * @return 剩余时间
     */
    long getExpire(String key);

    /**
     * 获取剩余时间
     *
     * @param k    主键，用于标识数据的主键
     * @param subK 子键，用于标识数据的子键
     * @return boolean
     */
    long getExpire(String k, String subK);

    /**
     * 获取剩余时间
     *
     * @param key      储存的数据的键
     * @param timeUnit 时长类型
     * @return 剩余时间
     */
    long getExpire(String key, TimeUnit timeUnit);

    /**
     * 获取剩余时间
     *
     * @param k        主键，用于标识数据的主键
     * @param subK     子键，用于标识数据的子键
     * @param timeUnit 时长类型
     * @return boolean
     */
    long getExpire(String k, String subK, TimeUnit timeUnit);

    /**
     * 判断key是否存在
     * 该方法用于检查给定的键和子键组合是否存在于数据结构中
     * 它通过将键和子键连接起来形成一个复合键，然后检查这个复合键是否存在
     *
     * @param k    主键，用于标识数据的主要类别或范围
     * @param subK 子键，用于在主键下进一步细化标识数据
     * @return boolean 返回一个布尔值，表示复合键是否存在于数据结构中
     */
    boolean containsKey(String k, String subK);

    /**
     * 判断key是否存在
     *
     * @param k 储存的数据的键
     * @return boolean
     */
    boolean containsKey(String k);

    /**
     * 移除某个k
     *
     * @param k 储存的数据的键
     * @return 是否移除成功
     */
    boolean delKey(String k);

    /**
     * 移除某个k
     * 该方法用于检查给定的键和子键组合是否存在于数据结构中
     * 它通过将键和子键连接起来形成一个复合键，然后检查这个复合键是否存在
     *
     * @param k    主键，用于标识数据的主键
     * @param subK 子键，用于标识数据的子键
     * @return 是否移除成功
     */
    boolean delKey(String k, String subK);

    /**
     * 移除一批
     *
     * @param kSet 储存的数据的键
     * @return 是否移除成功
     */
    long delKey(Set<String> kSet);

    /**
     * 移除一批
     *
     * @param k       主键，用于标识数据的主键
     * @param subKSet 子键，用于标识数据的子键
     * @return 是否移除成功
     */
    long delKey(String k, Set<String> subKSet);


/**
 * --------------------------------------------String------------------------------------------
 */

    /**
     * 获取单个k缓存
     *
     * @param k    储存的数据的键
     * @param subK 储存的数据的键
     * @return 获取缓存的value
     */
    <T> T get(String k, String subK);

    /**
     * 获取单个k缓存
     *
     * @param k 储存的数据的键
     * @return 获取缓存的value
     */
    <T> T get(String k);

    /**
     * 缓存set操作
     * <p>
     * 该方法用于检查给定的键和子键组合是否存在于数据结构中
     * 它通过将键和子键连接起来形成一个复合键，然后检查这个复合键是否存在
     *
     * @param k    主键，用于标识数据的主键
     * @param subK 子键，用于标识数据的子键
     * @param v    储存的数据的值
     * @return boolean
     */
    <T> boolean set(String k, String subK, final T v);

    /**
     * 缓存set操作
     *
     * @param k 储存的数据的键
     * @param v 储存的数据的值
     * @return boolean
     */
    <T> boolean set(String k, final T v);

    /**
     * 缓存set操作
     * <p>
     * 该方法用于检查给定的键和子键组合是否存在于数据结构中
     * 它通过将键和子键连接起来形成一个复合键，然后检查这个复合键是否存在
     *
     * @param k       主键，用于标识数据的主键
     * @param subK    子键，用于标识数据的子键
     * @param v       储存的数据的值
     * @param seconds 数据的生命时长 （秒）
     * @return set状态
     */
    <T> boolean set(String k, String subK, final T v, long seconds);

    /**
     * 缓存set操作
     *
     * @param k       储存的数据的键
     * @param v       储存的数据的值
     * @param seconds 数据的生命时长 （秒）
     * @return set状态
     */
    <T> boolean set(String k, final T v, long seconds);

    /**
     * 缓存set操作
     * <p>
     * 该方法用于检查给定的键和子键组合是否存在于数据结构中
     * 它通过将键和子键连接起来形成一个复合键，然后检查这个复合键是否存在
     *
     * @param k       主键，用于标识数据的主键
     * @param subK    子键，用于标识数据的子键
     * @param v       储存的数据的值
     * @param timeout 数据的生命时长
     * @param unit    时长类型
     * @return set状态
     */
    <T> boolean set(String k, String subK, final T v, long timeout, TimeUnit unit);

    /**
     * 缓存set操作
     *
     * @param k       储存的数据的键
     * @param v       储存的数据的值
     * @param timeout 数据的生命时长
     * @param unit    时长类型
     * @return set状态
     */
    <T> boolean set(String k, final T v, long timeout, TimeUnit unit);

    /**
     * 如果键不存在则新增,存在则不改变已经有的值
     * <p>
     * 该方法用于检查给定的键和子键组合是否存在于数据结构中
     * 它通过将键和子键连接起来形成一个复合键，然后检查这个复合键是否存在
     *
     * @param k    主键，用于标识数据的主键
     * @param subK 子键，用于标识数据的子键
     * @param v    储存的数据的值
     * @return <T>boolean
     */
    <T> boolean setIfAbsent(String k, String subK, final T v);

    /**
     * 如果键不存在则新增,存在则不改变已经有的值
     *
     * @param k 储存的数据的键
     * @param v 储存的数据的值
     * @return <T>boolean
     */
    <T> boolean setIfAbsent(String k, final T v);

    /**
     * 如果键不存在则新增,存在则不改变已经有的值
     * <p>
     * 该方法用于检查给定的键和子键组合是否存在于数据结构中
     * 它通过将键和子键连接起来形成一个复合键，然后检查这个复合键是否存在
     *
     * @param k       主键，用于标识数据的主键
     * @param subK    子键，用于标识数据的子键
     * @param v       储存的数据的值
     * @param seconds 数据的生命时长 （秒）
     * @return <T>boolean
     */
    <T> boolean setIfAbsent(String k, String subK, final T v, long seconds);

    /**
     * 如果键不存在则新增,存在则不改变已经有的值
     *
     * @param k       储存的数据的键
     * @param v       储存的数据的值
     * @param seconds 数据的生命时长 （秒）
     * @return <T>boolean
     */
    <T> boolean setIfAbsent(String k, final T v, long seconds);

    /**
     * 如果键不存在则新增,存在则不改变已经有的值
     * <p>
     * 该方法用于检查给定的键和子键组合是否存在于数据结构中
     * 它通过将键和子键连接起来形成一个复合键，然后检查这个复合键是否存在
     *
     * @param k        主键，用于标识数据的主键
     * @param subK     子键，用于标识数据的子键
     * @param v        储存的数据的值
     * @param time     存活时间
     * @param timeUnit 时间单位
     * @return <T>boolean
     */
    <T> boolean setIfAbsent(String k, String subK, final T v, long time, TimeUnit timeUnit);

    /**
     * 如果键不存在则新增,存在则不改变已经有的值
     *
     * @param k        储存的数据的键
     * @param v        储存的数据的值
     * @param time     存活时间
     * @param timeUnit 时间单位
     * @return <T>boolean
     */
    <T> boolean setIfAbsent(String k, final T v, long time, TimeUnit timeUnit);

    /**
     * 计数器
     * <p>
     * 该方法用于检查给定的键和子键组合是否存在于数据结构中
     * 它通过将键和子键连接起来形成一个复合键，然后检查这个复合键是否存在
     *
     * @param k     主键，用于标识数据的主键
     * @param subK  子键，用于标识数据的子键
     * @param delta 累计数
     * @return 结果
     */
    Long increment(String k, String subK, Long delta);


    /**
     * 计数器
     *
     * @param k     key
     * @param delta 累计数
     * @return 结果
     */
    Long increment(String k, Long delta);


    /**
     * 计数器
     *
     * @param k       储存的数据的键
     * @param subK    储存的数据的键
     * @param delta   累计数
     * @param seconds 存活时间（秒）
     * @return 结果
     */
    Long increment(String k, String subK, Long delta, long seconds);


    /**
     * 计数器
     *
     * @param k       k
     * @param delta   累加次数
     * @param seconds 存活时间（秒）
     * @return 结果
     */
    Long increment(String k, Long delta, long seconds);


    /**
     * 计数器
     *
     * @param k        储存的数据的键
     * @param subK     储存的数据的键
     * @param delta    累计数
     * @param time     存活时间
     * @param timeUnit 时间单位
     * @return 结果
     */
    Long increment(String k, String subK, Long delta, long time, TimeUnit timeUnit);

    /**
     * 计数器
     *
     * @param k        储存的数据的键
     * @param delta    累计数
     * @param time     存活时间
     * @param timeUnit 时间单位
     * @return 结果
     */
    Long increment(String k, Long delta, long time, TimeUnit timeUnit);

    /**
     * 计数器
     * <p>
     * 该方法用于检查给定的键和子键组合是否存在于数据结构中
     * 它通过将键和子键连接起来形成一个复合键，然后检查这个复合键是否存在
     *
     * @param k     主键，用于标识数据的主键
     * @param subK  子键，用于标识数据的子键
     * @param delta 累计数
     * @return 结果
     */
    Double increment(String k, String subK, double delta);

    /**
     * 计数器
     *
     * @param k     主键，用于标识数据的主键
     * @param delta 累计数
     * @return 结果
     */
    Double increment(String k, double delta);

    /**
     * 计数器
     *
     * @param k       主键，用于标识数据的主键
     * @param subK    子键，用于标识数据的子键
     * @param delta   累计数
     * @param seconds 存活时间（秒）
     * @return 结果
     */
    Double increment(String k, String subK, double delta, long seconds);


    /**
     * 计数器
     *
     * @param k       k
     * @param delta   累计数
     * @param seconds 存活时间（秒）
     * @return 结果
     */
    Double increment(String k, double delta, long seconds);

    /**
     * 计数器
     *
     * @param k        储存的数据的键
     * @param subK     储存的数据的键
     * @param delta    累计数
     * @param time     存活时间
     * @param timeUnit 时间单位
     * @return 结果
     */
    Double increment(String k, String subK, double delta, long time, TimeUnit timeUnit);

    /**
     * 计数器
     *
     * @param k        储存的数据的键
     * @param delta    累计数
     * @param time     存活时间
     * @param timeUnit 时间单位
     * @return 结果
     */
    Double increment(String k, double delta, long time, TimeUnit timeUnit);

    /**
     * 计数器
     *
     * @param k    储存的数据的键
     * @param subK 储存的数据的键
     * @return 结果
     */
    Long increment(String k, String subK);

    /**
     * 计数器
     *
     * @param k 储存的数据的键
     * @return 结果
     */
    Long increment(String k);


    /**
     * 计数器
     *
     * @param k       储存的数据的键
     * @param subK    储存的数据的键
     * @param seconds 存活时间（秒）
     * @return 结果
     */
    Long increment(String k, String subK, long seconds);

    /**
     * 计数器
     *
     * @param k       储存的数据的键
     * @param seconds 存活时间（秒）
     * @return 结果
     */
    Long increment(String k, long seconds);

    /**
     * 计数器
     *
     * @param k        储存的数据的键
     * @param subK     储存的数据的键
     * @param time     存活时间
     * @param timeUnit 时间单位
     * @return 结果
     */
    Long increment(String k, String subK, long time, TimeUnit timeUnit);

    /**
     * 计数器
     *
     * @param k        储存的数据的键
     * @param time     存活时间
     * @param timeUnit 时间单位
     * @return 结果
     */
    Long increment(String k, long time, TimeUnit timeUnit);


/**
 * --------------------------------------------hash---------------------------------------------
 */

    /**
     * 缓存Hash
     *
     * @param k    储存的数据的键
     * @param subK 储存的数据的键
     * @param v    储存的数据的值
     * @return 缓存的结果
     */
    <T> boolean putAll(String k, String subK, T v);

    /**
     * 缓存Hash
     *
     * @param k 储存的数据的键
     * @param v 储存的数据的值
     * @return 缓存的结果
     */
    <T> boolean putAll(String k, T v);

    /**
     * 缓存hash
     *
     * @param k    储存的数据的键
     * @param subK 储存的数据的键
     * @param v    储存的数据的值
     * @return 缓存的结果
     */
    <T> boolean putAll(String k, String subK, Map<String, T> v);

    /**
     * 缓存hash
     *
     * @param k 储存的数据的键
     * @param v 储存的数据的值
     * @return 缓存的结果
     */
    <T> boolean putAll(String k, Map<String, T> v);

    /**
     * 缓存Hash操作
     *
     * @param k    储存的数据的键
     * @param subK 储存的数据的键
     * @param v    储存的数据的值
     * @param time 数据的生命时长
     * @return set状态
     */
    <T> boolean putAll(String k, String subK, final Map<String, T> v, long time);

    /**
     * 缓存Hash操作
     *
     * @param k    储存的数据的键
     * @param v    储存的数据的值
     * @param time 数据的生命时长
     * @return set状态
     */
    <T> boolean putAll(String k, final Map<String, T> v, long time);

    /**
     * 缓存Hash操作
     *
     * @param k    储存的数据的键
     * @param subK 储存的数据的键
     * @param v    储存的数据的值
     * @param time 数据的生命时长
     * @return set状态
     */
    <T> boolean putAll(String k, String subK, final T v, long time);

    /**
     * 缓存Hash操作
     *
     * @param k    储存的数据的键
     * @param v    储存的数据的值
     * @param time 数据的生命时长
     * @return set状态
     */
    <T> boolean putAll(String k, final T v, long time);

    /**
     * 缓存Hash操作
     *
     * @param k       储存的数据的键
     * @param subK    储存的数据的键
     * @param v       储存的数据的值
     * @param timeout 数据的生命时长
     * @param unit    时长类型
     * @return boolean
     */
    <T> boolean putAll(String k, String subK, T v, long timeout, TimeUnit unit);

    /**
     * 缓存Hash操作
     *
     * @param k       储存的数据的键
     * @param v       储存的数据的值
     * @param timeout 数据的生命时长
     * @param unit    时长类型
     * @return boolean
     */
    <T> boolean putAll(String k, T v, long timeout, TimeUnit unit);

    /**
     * 缓存Hash操作
     *
     * @param k       储存的数据的键
     * @param subK    储存的数据的键
     * @param v       储存的数据的值
     * @param timeout 数据的生命时长
     * @param unit    时长类型
     * @return boolean
     */
    <T> boolean putAll(String k, String subK, final Map<String, T> v, long timeout, TimeUnit unit);

    /**
     * 缓存Hash操作
     *
     * @param k       储存的数据的键
     * @param v       储存的数据的值
     * @param timeout 数据的生命时长
     * @param unit    时长类型
     * @return boolean
     */
    <T> boolean putAll(String k, final Map<String, T> v, long timeout, TimeUnit unit);

    /**
     * 获取单个k缓存
     *
     * @param k    储存的数据的键
     * @param subK 储存的数据的键
     * @return 获取缓存的value
     */
    <T> T getHash(String k, String subK, Class<T> clazz);

    /**
     * 获取单个k缓存
     *
     * @param k 储存的数据的键
     * @return 获取缓存的value
     */
    <T> T getHash(String k, Class<T> clazz);

    /**
     * 获取单个k缓存
     *
     * @param k    储存的数据的键
     * @param subK 储存的数据的键
     * @return 获取缓存的value
     */
    <T> Map<String, T> getHash(String k, String subK);

    /**
     * 获取单个k缓存
     *
     * @param k 储存的数据的键
     * @return 获取缓存的value
     */
    <T> Map<String, T> getHash(String k);

    /**
     * 获取单个k缓存
     *
     * @param k    储存的数据的键
     * @param subK 储存的数据的键
     * @return 获取缓存的value
     */
    //<T> T getHash(String k, String subK, SFunction<T, ?>... fn);

    /**
     * 获取单个k缓存
     *
     * @param k 储存的数据的键
     * @return 获取缓存的value
     */
    //<T> T getHash(String k, SFunction<T, ?>... fn);


/**
 * --------------------------------------set-----------------------------------------------
 */
    /**
     * 缓存set
     *
     * @param k    储存的数据的键
     * @param subK 储存的数据的键
     * @param v    储存的数据的值
     * @return 缓存的结果
     */
    <T> boolean cacheSet(String k, String subK, final T v);

    /**
     * 缓存set操作
     *
     * @param k    储存的数据的键
     * @param subK 储存的数据的键
     * @param v    储存的数据的值
     * @param time 数据的生命时长
     * @return set状态
     */
    <T> boolean cacheSet(String k, String subK, final T v, long time);

    /**
     * 缓存set
     *
     * @param k    储存的数据的键
     * @param subK 储存的数据的键
     * @param v    储存的数据的值
     * @return 存入的状态
     */
    <T> boolean cacheSet(String k, String subK, Set<T> v);

    /**
     * 缓存set
     *
     * @param k    储存的数据的键
     * @param subK 储存的数据的键
     * @param v    储存的数据的值
     * @param time 存入的时间
     * @return 存入的转台
     */
    <T> boolean cacheSet(String k, String subK, Set<T> v, long time);


    /**
     * 获取缓存set数据
     *
     * @param k    储存的数据的键
     * @param subK 储存的数据的键
     * @return 缓存的值
     */
    <T> Set<T> getSet(String k, String subK);

    /**
     * 缓存list
     *
     * @param k    储存的数据的键
     * @param subK 储存的数据的键
     * @param v    储存的数据的值
     * @return 缓存一个集合
     */
    <T> boolean cacheList(String k, String subK, final T v);

    /**
     * 向一个list集合中添加新项
     *
     * @param k    储存的数据的键
     * @param subK 储存的数据的键
     * @param v    储存的数据的值
     * @param time 缓存的时间
     * @return 缓存的状态
     */
    <T> boolean cacheList(String k, String subK, final T v, long time);

    /**
     * 缓存list
     *
     * @param k    储存的数据的键
     * @param subK 储存的数据的键
     * @param v    储存的数据的值
     * @return 缓存状态
     */
    <T> boolean cacheList(String k, String subK, List<T> v);

    /**
     * 缓存一个list
     *
     * @param k    储存的数据的键
     * @param subK 储存的数据的键
     * @param v    储存的数据的值
     * @param time 缓存的时间
     * @return 缓存的状态
     */
    <T> boolean cacheList(String k, String subK, List<T> v, long time);

    /**
     * 向左缓存一个list
     *
     * @param k    储存的数据的键
     * @param subK 储存的数据的键
     * @param v    储存的数据的值
     * @return 缓存的状态
     */
    <T> boolean cacheLeftList(String k, String subK, List<T> v);

    /**
     * 向左缓存一个list
     *
     * @param k    储存的数据的键
     * @param subK 储存的数据的键
     * @param v    储存的数据的值
     * @param time 缓存的时间
     * @return 缓存的状态
     */
    <T> boolean cacheLeftList(String k, String subK, List<T> v, long time);

    <T> List<T> getList(String k, String subK);

    /**
     * 获取list缓存
     *
     * @param k     储存的数据的键
     * @param subK  储存的数据的键
     * @param start 开始获取的位置
     * @param end   结束获取的位置
     * @return 集合
     */
    <T> List<T> getList(String k, String subK, long start, long end);

    /**
     * 获取总条数, 可用于分页
     *
     * @param k    储存的数据的键
     * @param subK 储存的数据的键
     * @return 集合的长度
     */
    long getListSize(String k, String subK);

    /**
     * 获取总条数, 可用于分页
     *
     * @param listOps 获取集合的size
     * @param k       储存的数据的键
     * @return 集合的长度
     */
/*    long getListSize(ListOperations<String, String> listOps, String k) {
        try {
            return listOps.size(k);
        } catch (Throwable t) {
            log.error("获取list长度失败k[" + k + "], error[" + t + "]");
        }
        return 0;
    }*/

    /**
     * 移除并list中的首项
     *
     * @param k    储存的数据的键
     * @param subK 储存的数据的键
     * @return 移除结果
     */
    <T> boolean removeOneOfList(String k, String subK);

    /**
     * 移除对应的 value
     *
     * @param k    储存的数据的键
     * @param subK 储存的数据的键
     * @param v    值
     * @return
     */
    <T> boolean removeListValue(String k, String subK, T v);

    /**
     * 移除对应的 value
     *
     * @param k    储存的数据的键
     * @param subK 储存的数据的键
     * @param list list
     * @return
     */
    <T> boolean removeList(String k, String subK, List<String> list);


    /**
     * --------------------------------------------byte------------------------------------------
     */

    /**
     * 缓存byte数据
     *
     * @param k       储存的数据的键
     * @param subK    储存的数据的键
     * @param v       储存的数据的值
     * @param timeout 数据的生命时长
     * @param unit    时长类型
     * @return boolean
     */
    @Deprecated
    <T> boolean setByte(String k, String subK, final T v, long timeout, TimeUnit unit);

    /**
     * 缓存byte数据
     *
     * @param k    储存的数据的键
     * @param subK 储存的数据的键
     * @param v    储存的数据的值
     * @return <T>boolean
     */
    @Deprecated
    <T> boolean setByte(String k, String subK, final T v);

    /**
     * 获取byte数据
     *
     * @param k    储存的数据的键
     * @param subK 储存的数据的键
     * @return byte[]
     */
    @Deprecated
    byte[] getByte(String k, String subK);

    /**
     * 缓存byte数据
     *
     * @param k      储存的数据的键
     * @param subK   储存的数据的键
     * @param tClass 转换的类型
     * @return <T>boolean
     */
    @Deprecated
    <T> T getByte(String k, String subK, Class<T> tClass);


}
